wildcard-match

What is wildcard-match?

The wildcard-match npm package is used for matching strings against wildcard patterns. It is useful for tasks such as filtering file paths, validating input strings, and more.

What are wildcard-match's main functionalities?

Basic Wildcard Matching

This feature allows you to check if a string matches a given wildcard pattern. In this example, 'foobar' matches the pattern 'foo*'.

const wildcard = require('wildcard-match');
const isMatch = wildcard('foo*')('foobar');
console.log(isMatch); // true

Case-Insensitive Matching

This feature allows for case-insensitive matching. In this example, 'FOOBAR' matches the pattern 'foo*' when case sensitivity is turned off.

const wildcard = require('wildcard-match');
const isMatch = wildcard('foo*', { caseSensitive: false })('FOOBAR');
console.log(isMatch); // true

Custom Wildcard Characters

This feature allows you to define custom wildcard characters. In this example, '#' is used as the wildcard character instead of the default '*'.

const wildcard = require('wildcard-match');
const isMatch = wildcard('foo#', { wildcard: '#' })('foo123');
console.log(isMatch); // true

Other packages similar to wildcard-match

minimatch

Minimatch is a powerful glob matching library that supports a wide range of glob patterns. It is more feature-rich compared to wildcard-match, offering advanced pattern matching capabilities.

micromatch

Micromatch is a fast and lightweight glob matcher that supports extended glob patterns and advanced matching features. It is known for its performance and flexibility, making it a good alternative to wildcard-match.

multimatch

Multimatch is a library that allows you to match multiple glob patterns against a list of strings. It is built on top of minimatch and provides additional functionality for handling multiple patterns efficiently.

README

wildcard-match

A tiny and extremely fast JavaScript library for compiling and matching basic glob patterns

     

Wildcard-match takes one or more basic glob patterns, compiles them into a RegExp and returns a function for matching strings with it.

Glob patterns are strings that contain ?, * and ** wildcards. When such a pattern is compared with another string, these wildcards can replace one or more symbols. For example, src/* would match both src/foo and src/bar.

This library's goal is to be as small and as fast as possible while supporting only the most basic wildcards. If you need character ranges, extended globs, braces and other advanced features, check out outmatch.

Quickstart

npm install wildcard-match

import wcmatch from 'wildcard-match'

const isMatch = wcmatch('src/**/*.?s')

isMatch('src/components/header/index.js') //=> true
isMatch('src/README.md') //=> false

isMatch.pattern //=> 'src/**/*.?s'
isMatch.options //=> { separator: true }
isMatch.regexp //=> /^src[/\\]+?(?:[^/\\]*?[/\\]+?)*?[^/\\]*?\.[^/\\]s[/\\]*?$/

More details are available in the Installation, Usage and API sections.

Features

🍃	Lightweight No dependencies. Less than 1 KB when minified and gzipped
🏎	Fast Compiles and matches patterns faster than any other known library
🌞	Simple The API is a single function
⚒	Reliable Written in TypeScript. Covered by hundreds of unit tests
🔌	Compatible Works in any ES5+ environment including older versions of Node.js, Deno, React Native and browsers

For comparison with the alternatives, see the corresponding section.

Installation

The package is distributed via the npm package registry. It can be installed using one of the compatible package managers or included directly from a CDN.

npm

npm install wildcard-match

Yarn

yarn add wildcard-match

pnpm

pnpm install wildcard-match

CDN

When included from a CDN, wildcard-match is available as the global function wcmatch.

• unpkg
• jsDelivr

Usage

Basics

Wildcard-match comes built in ESM, CommonJS and UMD formats and includes TypeScript typings. The examples use ESM imports, which can be replaced with the following line for CommonJS: const wcmatch = require('wildcard-match').

The default export is a function of two arguments, first of which can be either a single glob string or an array of such patterns. The second argument is optional and can be either an options object or a separator (which will be the value of the separator option). Wildcard-match compiles them into a regular expression and returns a function (usually called isMatch in the examples) that tests strings against the pattern. The pattern, options and the compiled RegExp object are available as properties on the returned function:

import wcmatch from 'wildcard-match'

const isMatch = wcmatch('src/?ar')

isMatch('src/bar') //=> true
isMatch('src/car') //=> true
isMatch('src/cvar') //=> false

isMatch.pattern //=> 'src/?ar'
isMatch.options //=> {}
isMatch.regexp //=> /^src[/\\]+?[^/\\]ar[/\\]*?$/

The returned function can be invoked immediately if there is no need to match a pattern more than once:

wcmatch('src/**/*.js')('src/components/body/index.js') //=> true

Compiling a pattern is much slower than comparing a string to it, so it is recommended to always reuse the returned function when possible.

Syntax

Wildcard-match supports the following glob syntax in patterns:

• ? matches exactly one arbitrary character excluding separators
• * matches zero or more arbitrary characters excluding separators
• ** matches any number of segments when used as a whole segment in a separated pattern (e.g. /**/ if / is the separator)
• \ escapes the following character making it be treated literally

More features are available in the outmatch library.

Separators

Globs are most often used to search file paths, which are, essentially, strings split into segments by slashes. While other libraries are usually restricted to this use-case, wildcard-match is able to work with arbitrary strings by accepting a custom separator in the second parameter:

const matchDomain = wcmatch('*.example.com', { separator: '.' })
matchDomain('subdomain.example.com') //=> true

// Here, the second parameter is a shorthand for `{ separator: ',' }`
const matchLike = wcmatch('one,**,f?ur', ',')
matchLike('one,two,three,four') //=> true

The only limitation is that backslashes \ cannot be used as separators in patterns because wildcard-match uses them for character escaping. However, when separator is undefined or true, / in patterns will match both / and \, so a single pattern with forward slashes can match both Unix and Windows paths:

const isMatchA = outmatch('foo\\bar') // throws an error

const isMatchB = outmatch('foo/bar') // same as passing `true` as the separator

isMatchB('foo/bar') //=> true
isMatchB('foo\\bar') //=> true

const isMatchC = outmatch('foo/bar', '/')

isMatchC('foo/bar') //=> true
isMatchC('foo\\bar') //=> false

The matching features work with a segment rather than a whole pattern:

const isMatch = wcmatch('foo/b*')

isMatch('foo/bar') //=> true
isMatch('foo/b/ar') //=> false

Segmentation can be turned off completely by passing false as the separator, which makes wildcard-match treat whole patterns as a single segment. Slashes become regular symbols and * matches anything:

const isMatch = wcmatch('foo?ba*', false)
isMatch('foo/bar/qux') //=> true

A single separator in a pattern will match one or more separators in a sample string:

wcmatch('foo/bar/baz')('foo/bar///baz') //=> true

When a pattern has an explicit separator at its end, samples also require one or more trailing separators:

const isMatch = wcmatch('foo/bar/')

isMatch('foo/bar') //=> false
isMatch('foo/bar/') //=> true
isMatch('foo/bar///') //=> true

However, if there is no trailing separator in a pattern, strings will match even if they have separators at the end:

const isMatch = wcmatch('foo/bar')

isMatch('foo/bar') //=> true
isMatch('foo/bar/') //=> true
isMatch('foo/bar///') //=> true

Multiple Patterns

Wildcard-match can take an array of glob patterns as the first argument instead of a single pattern. In that case a string will be considered a match if it matches any of the given patterns:

const isMatch = wcmatch(['src/*', 'tests/*'])

isMatch('src/utils.js') //=> true
isMatch('tests/utils.js') //=> true

Matching Arrays of Strings

The returned function can work with arrays of strings when used as the predicate of the native array methods:

const isMatch = wcmatch('src/*.js')
const paths = ['readme.md', 'src/index.js', 'src/components/body.js']

paths.map(isMatch) //=> [ false, true, false ]
paths.filter(isMatch) //=> [ 'src/index.js' ]
paths.some(isMatch) //=> true
paths.every(isMatch) //=> false
paths.find(isMatch) //=> 'src/index.js'
paths.findIndex(isMatch) //=> 1

API

wcmatch(patterns, options?): isMatch
wcmatch(patterns, separator?): isMatch

Takes a single pattern string or an array of patterns and compiles them into a regular expression. Returns an isMatch function that takes a sample string as its only argument and returns true if the string matches the pattern(s).

isMatch(sample): boolean

Tests if a sample string matches the patterns that were used to compile the regular expression and create this function.

isMatch.regexp

The compiled regular expression.

isMatch.pattern

The original pattern or array of patterns that was used to compile the regular expression and create the isMatch function.

isMatch.options

The options object that was used to compile the regular expression and create the isMatch function.

Options

Option	Type	Default Value	Description
separator	string | boolean	true	Separator to be used to split patterns and samples into segments true — / in patterns match both / and \ in samples false — don't split any string — custom separator
flags	string	undefined	Flags to pass to the RegExp. For example, setting this option to 'i' will make the matching case-insensitive

Comparison

Pattern: src/test/**/*.?s
Sample: src/test/foo/bar.js

Compilation
  wildcard-match     1,046,326 ops/sec
  picomatch            261,589 ops/sec

Matching
  wildcard-match     34,646,993 ops/sec
  picomatch          10,750,888 ops/sec

A better comparison is in the works.